#include<vector>
#include<map>
#include<algorithm>
using namespace std;

class Solution {
public:
    vector<int> twoSum(vector<int> nums, int target) {
        map<int, int> mp;
        int n = nums.size();

        for (int i = 0; i < n; i ++) {
            if (mp[target - nums[i]] == 0) {
                // nums[i]为第i+1个元素
                mp[nums[i]] = i + 1;
            }else{
                int idx = mp[target - nums[i]];
                return vector<int> {nums[idx - 1], nums[i]};
            }
        }

        return {};
    }

    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int n = nums.size();

        vector<vector<int>> ans;
        vector<int> cur_ans;
        for (int i = 0; i < n; i++) {
            vector<int> cur = nums.earse(i);
            cur_ans = twoSum(cur, (0 - nums[i]));

            if (cur_ans.size() == 0) continue;
            ans.push_back(cur_ans);
            cur_ans.clear();
        }

        return ans;
    }
};


// 这段代码的问题较多，无法正常编译和运行，主要逻辑和语法错误如下：

// 1. `nums.earse(i)` 是拼写错误，应为 `nums.erase(nums.begin() + i)`。
// 2. `erase` 会直接修改原数组，破坏排序结果，且每次循环会导致索引混乱，不适合在循环中使用。
// 3. `twoSum` 函数返回的是满足条件的两个元素值，而非索引，`threeSum` 题目要求返回三个数的组合，不应调用 `twoSum` 返回值直接拼接。
// 4. `map<int,int>` 的判断方式 `if (mp[target - nums[i]] == 0)` 不可靠，因为键不存在时会自动插入默认值 0。
// 5. `threeSum` 问题中需要跳过重复元素，避免重复结果。

// 正确的 `threeSum` 实现方式如下，逻辑清晰且能通过所有测试用例：

// ```cpp
// class Solution {
// public:
//     vector<vector<int>> threeSum(vector<int>& nums) {
//         sort(nums.begin(), nums.end());
//         int n = nums.size();
//         vector<vector<int>> ans;

//         for (int i = 0; i < n - 2; i++) {
//             if (i > 0 && nums[i] == nums[i - 1]) continue; // 跳过重复的a
//             int left = i + 1, right = n - 1;
//             while (left < right) {
//                 int sum = nums[i] + nums[left] + nums[right];
//                 if (sum == 0) {
//                     ans.push_back({nums[i], nums[left], nums[right]});
//                     while (left < right && nums[left] == nums[left + 1]) left++;
//                     while (left < right && nums[right] == nums[right - 1]) right--;
//                     left++;
//                     right--;
//                 } else if (sum < 0) {
//                     left++;
//                 } else {
//                     right--;
//                 }
//             }
//         }
//         return ans;
//     }
// };
// ```

// 这种写法用排序加双指针方法解决 `threeSum`，时间复杂度为 `O(n^2)`，空间复杂度为 `O(1)`，逻辑比原始代码简洁且稳定。
